// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2008-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.

#ifndef EIGEN_SPARSE_BLOCK_H
#define EIGEN_SPARSE_BLOCK_H

namespace Eigen {

// Subset of columns or rows
template<typename XprType, int BlockRows, int BlockCols>
class BlockImpl<XprType, BlockRows, BlockCols, true, Sparse>
	: public SparseMatrixBase<Block<XprType, BlockRows, BlockCols, true>>
{
	typedef typename internal::remove_all<typename XprType::Nested>::type _MatrixTypeNested;
	typedef Block<XprType, BlockRows, BlockCols, true> BlockType;

  public:
	enum
	{
		IsRowMajor = internal::traits<BlockType>::IsRowMajor
	};

  protected:
	enum
	{
		OuterSize = IsRowMajor ? BlockRows : BlockCols
	};
	typedef SparseMatrixBase<BlockType> Base;
	using Base::convert_index;

  public:
	EIGEN_SPARSE_PUBLIC_INTERFACE(BlockType)

	inline BlockImpl(XprType& xpr, Index i)
		: m_matrix(xpr)
		, m_outerStart(convert_index(i))
		, m_outerSize(OuterSize)
	{
	}

	inline BlockImpl(XprType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
		: m_matrix(xpr)
		, m_outerStart(convert_index(IsRowMajor ? startRow : startCol))
		, m_outerSize(convert_index(IsRowMajor ? blockRows : blockCols))
	{
	}

	EIGEN_STRONG_INLINE Index rows() const { return IsRowMajor ? m_outerSize.value() : m_matrix.rows(); }
	EIGEN_STRONG_INLINE Index cols() const { return IsRowMajor ? m_matrix.cols() : m_outerSize.value(); }

	Index nonZeros() const
	{
		typedef internal::evaluator<XprType> EvaluatorType;
		EvaluatorType matEval(m_matrix);
		Index nnz = 0;
		Index end = m_outerStart + m_outerSize.value();
		for (Index j = m_outerStart; j < end; ++j)
			for (typename EvaluatorType::InnerIterator it(matEval, j); it; ++it)
				++nnz;
		return nnz;
	}

	inline const Scalar coeff(Index row, Index col) const
	{
		return m_matrix.coeff(row + (IsRowMajor ? m_outerStart : 0), col + (IsRowMajor ? 0 : m_outerStart));
	}

	inline const Scalar coeff(Index index) const
	{
		return m_matrix.coeff(IsRowMajor ? m_outerStart : index, IsRowMajor ? index : m_outerStart);
	}

	inline const XprType& nestedExpression() const { return m_matrix; }
	inline XprType& nestedExpression() { return m_matrix; }
	Index startRow() const { return IsRowMajor ? m_outerStart : 0; }
	Index startCol() const { return IsRowMajor ? 0 : m_outerStart; }
	Index blockRows() const { return IsRowMajor ? m_outerSize.value() : m_matrix.rows(); }
	Index blockCols() const { return IsRowMajor ? m_matrix.cols() : m_outerSize.value(); }

  protected:
	typename internal::ref_selector<XprType>::non_const_type m_matrix;
	Index m_outerStart;
	const internal::variable_if_dynamic<Index, OuterSize> m_outerSize;

  protected:
	// Disable assignment with clear error message.
	// Note that simply removing operator= yields compilation errors with ICC+MSVC
	template<typename T>
	BlockImpl& operator=(const T&)
	{
		EIGEN_STATIC_ASSERT(sizeof(T) == 0, THIS_SPARSE_BLOCK_SUBEXPRESSION_IS_READ_ONLY);
		return *this;
	}
};

/***************************************************************************
 * specialization for SparseMatrix
 ***************************************************************************/

namespace internal {

template<typename SparseMatrixType, int BlockRows, int BlockCols>
class sparse_matrix_block_impl : public SparseCompressedBase<Block<SparseMatrixType, BlockRows, BlockCols, true>>
{
	typedef typename internal::remove_all<typename SparseMatrixType::Nested>::type _MatrixTypeNested;
	typedef Block<SparseMatrixType, BlockRows, BlockCols, true> BlockType;
	typedef SparseCompressedBase<Block<SparseMatrixType, BlockRows, BlockCols, true>> Base;
	using Base::convert_index;

  public:
	enum
	{
		IsRowMajor = internal::traits<BlockType>::IsRowMajor
	};
	EIGEN_SPARSE_PUBLIC_INTERFACE(BlockType)
  protected:
	typedef typename Base::IndexVector IndexVector;
	enum
	{
		OuterSize = IsRowMajor ? BlockRows : BlockCols
	};

  public:
	inline sparse_matrix_block_impl(SparseMatrixType& xpr, Index i)
		: m_matrix(xpr)
		, m_outerStart(convert_index(i))
		, m_outerSize(OuterSize)
	{
	}

	inline sparse_matrix_block_impl(SparseMatrixType& xpr,
									Index startRow,
									Index startCol,
									Index blockRows,
									Index blockCols)
		: m_matrix(xpr)
		, m_outerStart(convert_index(IsRowMajor ? startRow : startCol))
		, m_outerSize(convert_index(IsRowMajor ? blockRows : blockCols))
	{
	}

	template<typename OtherDerived>
	inline BlockType& operator=(const SparseMatrixBase<OtherDerived>& other)
	{
		typedef typename internal::remove_all<typename SparseMatrixType::Nested>::type _NestedMatrixType;
		_NestedMatrixType& matrix = m_matrix;
		// This assignment is slow if this vector set is not empty
		// and/or it is not at the end of the nonzeros of the underlying matrix.

		// 1 - eval to a temporary to avoid transposition and/or aliasing issues
		Ref<const SparseMatrix<Scalar, IsRowMajor ? RowMajor : ColMajor, StorageIndex>> tmp(other.derived());
		eigen_internal_assert(tmp.outerSize() == m_outerSize.value());

		// 2 - let's check whether there is enough allocated memory
		Index nnz = tmp.nonZeros();
		Index start =
			m_outerStart == 0 ? 0 : m_matrix.outerIndexPtr()[m_outerStart]; // starting position of the current block
		Index end =
			m_matrix.outerIndexPtr()[m_outerStart + m_outerSize.value()]; // ending position of the current block
		Index block_size = end - start;									  // available room in the current block
		Index tail_size = m_matrix.outerIndexPtr()[m_matrix.outerSize()] - end;

		Index free_size = m_matrix.isCompressed() ? Index(matrix.data().allocatedSize()) + block_size : block_size;

		Index tmp_start = tmp.outerIndexPtr()[0];

		bool update_trailing_pointers = false;
		if (nnz > free_size) {
			// realloc manually to reduce copies
			typename SparseMatrixType::Storage newdata(m_matrix.data().allocatedSize() - block_size + nnz);

			internal::smart_copy(m_matrix.valuePtr(), m_matrix.valuePtr() + start, newdata.valuePtr());
			internal::smart_copy(m_matrix.innerIndexPtr(), m_matrix.innerIndexPtr() + start, newdata.indexPtr());

			internal::smart_copy(
				tmp.valuePtr() + tmp_start, tmp.valuePtr() + tmp_start + nnz, newdata.valuePtr() + start);
			internal::smart_copy(
				tmp.innerIndexPtr() + tmp_start, tmp.innerIndexPtr() + tmp_start + nnz, newdata.indexPtr() + start);

			internal::smart_copy(
				matrix.valuePtr() + end, matrix.valuePtr() + end + tail_size, newdata.valuePtr() + start + nnz);
			internal::smart_copy(matrix.innerIndexPtr() + end,
								 matrix.innerIndexPtr() + end + tail_size,
								 newdata.indexPtr() + start + nnz);

			newdata.resize(m_matrix.outerIndexPtr()[m_matrix.outerSize()] - block_size + nnz);

			matrix.data().swap(newdata);

			update_trailing_pointers = true;
		} else {
			if (m_matrix.isCompressed() && nnz != block_size) {
				// no need to realloc, simply copy the tail at its respective position and insert tmp
				matrix.data().resize(start + nnz + tail_size);

				internal::smart_memmove(
					matrix.valuePtr() + end, matrix.valuePtr() + end + tail_size, matrix.valuePtr() + start + nnz);
				internal::smart_memmove(matrix.innerIndexPtr() + end,
										matrix.innerIndexPtr() + end + tail_size,
										matrix.innerIndexPtr() + start + nnz);

				update_trailing_pointers = true;
			}

			internal::smart_copy(
				tmp.valuePtr() + tmp_start, tmp.valuePtr() + tmp_start + nnz, matrix.valuePtr() + start);
			internal::smart_copy(
				tmp.innerIndexPtr() + tmp_start, tmp.innerIndexPtr() + tmp_start + nnz, matrix.innerIndexPtr() + start);
		}

		// update outer index pointers and innerNonZeros
		if (IsVectorAtCompileTime) {
			if (!m_matrix.isCompressed())
				matrix.innerNonZeroPtr()[m_outerStart] = StorageIndex(nnz);
			matrix.outerIndexPtr()[m_outerStart] = StorageIndex(start);
		} else {
			StorageIndex p = StorageIndex(start);
			for (Index k = 0; k < m_outerSize.value(); ++k) {
				StorageIndex nnz_k = internal::convert_index<StorageIndex>(tmp.innerVector(k).nonZeros());
				if (!m_matrix.isCompressed())
					matrix.innerNonZeroPtr()[m_outerStart + k] = nnz_k;
				matrix.outerIndexPtr()[m_outerStart + k] = p;
				p += nnz_k;
			}
		}

		if (update_trailing_pointers) {
			StorageIndex offset = internal::convert_index<StorageIndex>(nnz - block_size);
			for (Index k = m_outerStart + m_outerSize.value(); k <= matrix.outerSize(); ++k) {
				matrix.outerIndexPtr()[k] += offset;
			}
		}

		return derived();
	}

	inline BlockType& operator=(const BlockType& other) { return operator=<BlockType>(other); }

	inline const Scalar* valuePtr() const { return m_matrix.valuePtr(); }
	inline Scalar* valuePtr() { return m_matrix.valuePtr(); }

	inline const StorageIndex* innerIndexPtr() const { return m_matrix.innerIndexPtr(); }
	inline StorageIndex* innerIndexPtr() { return m_matrix.innerIndexPtr(); }

	inline const StorageIndex* outerIndexPtr() const { return m_matrix.outerIndexPtr() + m_outerStart; }
	inline StorageIndex* outerIndexPtr() { return m_matrix.outerIndexPtr() + m_outerStart; }

	inline const StorageIndex* innerNonZeroPtr() const
	{
		return isCompressed() ? 0 : (m_matrix.innerNonZeroPtr() + m_outerStart);
	}
	inline StorageIndex* innerNonZeroPtr() { return isCompressed() ? 0 : (m_matrix.innerNonZeroPtr() + m_outerStart); }

	bool isCompressed() const { return m_matrix.innerNonZeroPtr() == 0; }

	inline Scalar& coeffRef(Index row, Index col)
	{
		return m_matrix.coeffRef(row + (IsRowMajor ? m_outerStart : 0), col + (IsRowMajor ? 0 : m_outerStart));
	}

	inline const Scalar coeff(Index row, Index col) const
	{
		return m_matrix.coeff(row + (IsRowMajor ? m_outerStart : 0), col + (IsRowMajor ? 0 : m_outerStart));
	}

	inline const Scalar coeff(Index index) const
	{
		return m_matrix.coeff(IsRowMajor ? m_outerStart : index, IsRowMajor ? index : m_outerStart);
	}

	const Scalar& lastCoeff() const
	{
		EIGEN_STATIC_ASSERT_VECTOR_ONLY(sparse_matrix_block_impl);
		eigen_assert(Base::nonZeros() > 0);
		if (m_matrix.isCompressed())
			return m_matrix.valuePtr()[m_matrix.outerIndexPtr()[m_outerStart + 1] - 1];
		else
			return m_matrix
				.valuePtr()[m_matrix.outerIndexPtr()[m_outerStart] + m_matrix.innerNonZeroPtr()[m_outerStart] - 1];
	}

	EIGEN_STRONG_INLINE Index rows() const { return IsRowMajor ? m_outerSize.value() : m_matrix.rows(); }
	EIGEN_STRONG_INLINE Index cols() const { return IsRowMajor ? m_matrix.cols() : m_outerSize.value(); }

	inline const SparseMatrixType& nestedExpression() const { return m_matrix; }
	inline SparseMatrixType& nestedExpression() { return m_matrix; }
	Index startRow() const { return IsRowMajor ? m_outerStart : 0; }
	Index startCol() const { return IsRowMajor ? 0 : m_outerStart; }
	Index blockRows() const { return IsRowMajor ? m_outerSize.value() : m_matrix.rows(); }
	Index blockCols() const { return IsRowMajor ? m_matrix.cols() : m_outerSize.value(); }

  protected:
	typename internal::ref_selector<SparseMatrixType>::non_const_type m_matrix;
	Index m_outerStart;
	const internal::variable_if_dynamic<Index, OuterSize> m_outerSize;
};

} // namespace internal

template<typename _Scalar, int _Options, typename _StorageIndex, int BlockRows, int BlockCols>
class BlockImpl<SparseMatrix<_Scalar, _Options, _StorageIndex>, BlockRows, BlockCols, true, Sparse>
	: public internal::sparse_matrix_block_impl<SparseMatrix<_Scalar, _Options, _StorageIndex>, BlockRows, BlockCols>
{
  public:
	typedef _StorageIndex StorageIndex;
	typedef SparseMatrix<_Scalar, _Options, _StorageIndex> SparseMatrixType;
	typedef internal::sparse_matrix_block_impl<SparseMatrixType, BlockRows, BlockCols> Base;
	inline BlockImpl(SparseMatrixType& xpr, Index i)
		: Base(xpr, i)
	{
	}

	inline BlockImpl(SparseMatrixType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
		: Base(xpr, startRow, startCol, blockRows, blockCols)
	{
	}

	using Base::operator=;
};

template<typename _Scalar, int _Options, typename _StorageIndex, int BlockRows, int BlockCols>
class BlockImpl<const SparseMatrix<_Scalar, _Options, _StorageIndex>, BlockRows, BlockCols, true, Sparse>
	: public internal::
		  sparse_matrix_block_impl<const SparseMatrix<_Scalar, _Options, _StorageIndex>, BlockRows, BlockCols>
{
  public:
	typedef _StorageIndex StorageIndex;
	typedef const SparseMatrix<_Scalar, _Options, _StorageIndex> SparseMatrixType;
	typedef internal::sparse_matrix_block_impl<SparseMatrixType, BlockRows, BlockCols> Base;
	inline BlockImpl(SparseMatrixType& xpr, Index i)
		: Base(xpr, i)
	{
	}

	inline BlockImpl(SparseMatrixType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
		: Base(xpr, startRow, startCol, blockRows, blockCols)
	{
	}

	using Base::operator=;

  private:
	template<typename Derived>
	BlockImpl(const SparseMatrixBase<Derived>& xpr, Index i);
	template<typename Derived>
	BlockImpl(const SparseMatrixBase<Derived>& xpr);
};

//----------

/** Generic implementation of sparse Block expression.
 * Real-only.
 */
template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
class BlockImpl<XprType, BlockRows, BlockCols, InnerPanel, Sparse>
	: public SparseMatrixBase<Block<XprType, BlockRows, BlockCols, InnerPanel>>
	, internal::no_assignment_operator
{
	typedef Block<XprType, BlockRows, BlockCols, InnerPanel> BlockType;
	typedef SparseMatrixBase<BlockType> Base;
	using Base::convert_index;

  public:
	enum
	{
		IsRowMajor = internal::traits<BlockType>::IsRowMajor
	};
	EIGEN_SPARSE_PUBLIC_INTERFACE(BlockType)

	typedef typename internal::remove_all<typename XprType::Nested>::type _MatrixTypeNested;

	/** Column or Row constructor
	 */
	inline BlockImpl(XprType& xpr, Index i)
		: m_matrix(xpr)
		, m_startRow((BlockRows == 1) && (BlockCols == XprType::ColsAtCompileTime) ? convert_index(i) : 0)
		, m_startCol((BlockRows == XprType::RowsAtCompileTime) && (BlockCols == 1) ? convert_index(i) : 0)
		, m_blockRows(BlockRows == 1 ? 1 : xpr.rows())
		, m_blockCols(BlockCols == 1 ? 1 : xpr.cols())
	{
	}

	/** Dynamic-size constructor
	 */
	inline BlockImpl(XprType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
		: m_matrix(xpr)
		, m_startRow(convert_index(startRow))
		, m_startCol(convert_index(startCol))
		, m_blockRows(convert_index(blockRows))
		, m_blockCols(convert_index(blockCols))
	{
	}

	inline Index rows() const { return m_blockRows.value(); }
	inline Index cols() const { return m_blockCols.value(); }

	inline Scalar& coeffRef(Index row, Index col)
	{
		return m_matrix.coeffRef(row + m_startRow.value(), col + m_startCol.value());
	}

	inline const Scalar coeff(Index row, Index col) const
	{
		return m_matrix.coeff(row + m_startRow.value(), col + m_startCol.value());
	}

	inline Scalar& coeffRef(Index index)
	{
		return m_matrix.coeffRef(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
								 m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
	}

	inline const Scalar coeff(Index index) const
	{
		return m_matrix.coeff(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
							  m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
	}

	inline const XprType& nestedExpression() const { return m_matrix; }
	inline XprType& nestedExpression() { return m_matrix; }
	Index startRow() const { return m_startRow.value(); }
	Index startCol() const { return m_startCol.value(); }
	Index blockRows() const { return m_blockRows.value(); }
	Index blockCols() const { return m_blockCols.value(); }

  protected:
	//     friend class internal::GenericSparseBlockInnerIteratorImpl<XprType,BlockRows,BlockCols,InnerPanel>;
	friend struct internal::
		unary_evaluator<Block<XprType, BlockRows, BlockCols, InnerPanel>, internal::IteratorBased, Scalar>;

	Index nonZeros() const { return Dynamic; }

	typename internal::ref_selector<XprType>::non_const_type m_matrix;
	const internal::variable_if_dynamic<Index, XprType::RowsAtCompileTime == 1 ? 0 : Dynamic> m_startRow;
	const internal::variable_if_dynamic<Index, XprType::ColsAtCompileTime == 1 ? 0 : Dynamic> m_startCol;
	const internal::variable_if_dynamic<Index, RowsAtCompileTime> m_blockRows;
	const internal::variable_if_dynamic<Index, ColsAtCompileTime> m_blockCols;

  protected:
	// Disable assignment with clear error message.
	// Note that simply removing operator= yields compilation errors with ICC+MSVC
	template<typename T>
	BlockImpl& operator=(const T&)
	{
		EIGEN_STATIC_ASSERT(sizeof(T) == 0, THIS_SPARSE_BLOCK_SUBEXPRESSION_IS_READ_ONLY);
		return *this;
	}
};

namespace internal {

template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
struct unary_evaluator<Block<ArgType, BlockRows, BlockCols, InnerPanel>, IteratorBased>
	: public evaluator_base<Block<ArgType, BlockRows, BlockCols, InnerPanel>>
{
	class InnerVectorInnerIterator;
	class OuterVectorInnerIterator;

  public:
	typedef Block<ArgType, BlockRows, BlockCols, InnerPanel> XprType;
	typedef typename XprType::StorageIndex StorageIndex;
	typedef typename XprType::Scalar Scalar;

	enum
	{
		IsRowMajor = XprType::IsRowMajor,

		OuterVector = (BlockCols == 1 &&
					   ArgType::IsRowMajor) | // FIXME | instead of || to please GCC 4.4.0 stupid warning "suggest
											  // parentheses around &&". revert to || as soon as not needed anymore.
					  (BlockRows == 1 && !ArgType::IsRowMajor),

		CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
		Flags = XprType::Flags
	};

	typedef typename internal::conditional<OuterVector, OuterVectorInnerIterator, InnerVectorInnerIterator>::type
		InnerIterator;

	explicit unary_evaluator(const XprType& op)
		: m_argImpl(op.nestedExpression())
		, m_block(op)
	{
	}

	inline Index nonZerosEstimate() const
	{
		const Index nnz = m_block.nonZeros();
		if (nnz < 0) {
			// Scale the non-zero estimate for the underlying expression linearly with block size.
			// Return zero if the underlying block is empty.
			const Index nested_sz = m_block.nestedExpression().size();
			return nested_sz == 0 ? 0 : m_argImpl.nonZerosEstimate() * m_block.size() / nested_sz;
		}
		return nnz;
	}

  protected:
	typedef typename evaluator<ArgType>::InnerIterator EvalIterator;

	evaluator<ArgType> m_argImpl;
	const XprType& m_block;
};

template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
class unary_evaluator<Block<ArgType, BlockRows, BlockCols, InnerPanel>, IteratorBased>::InnerVectorInnerIterator
	: public EvalIterator
{
	// NOTE MSVC fails to compile if we don't explicitely "import" IsRowMajor from unary_evaluator
	//      because the base class EvalIterator has a private IsRowMajor enum too. (bug #1786)
	// NOTE We cannot call it IsRowMajor because it would shadow unary_evaluator::IsRowMajor
	enum
	{
		XprIsRowMajor = unary_evaluator::IsRowMajor
	};
	const XprType& m_block;
	Index m_end;

  public:
	EIGEN_STRONG_INLINE InnerVectorInnerIterator(const unary_evaluator& aEval, Index outer)
		: EvalIterator(aEval.m_argImpl, outer + (XprIsRowMajor ? aEval.m_block.startRow() : aEval.m_block.startCol()))
		, m_block(aEval.m_block)
		, m_end(XprIsRowMajor ? aEval.m_block.startCol() + aEval.m_block.blockCols()
							  : aEval.m_block.startRow() + aEval.m_block.blockRows())
	{
		while ((EvalIterator::operator bool()) &&
			   (EvalIterator::index() < (XprIsRowMajor ? m_block.startCol() : m_block.startRow())))
			EvalIterator::operator++();
	}

	inline StorageIndex index() const
	{
		return EvalIterator::index() -
			   convert_index<StorageIndex>(XprIsRowMajor ? m_block.startCol() : m_block.startRow());
	}
	inline Index outer() const
	{
		return EvalIterator::outer() - (XprIsRowMajor ? m_block.startRow() : m_block.startCol());
	}
	inline Index row() const { return EvalIterator::row() - m_block.startRow(); }
	inline Index col() const { return EvalIterator::col() - m_block.startCol(); }

	inline operator bool() const { return EvalIterator::operator bool() && EvalIterator::index() < m_end; }
};

template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
class unary_evaluator<Block<ArgType, BlockRows, BlockCols, InnerPanel>, IteratorBased>::OuterVectorInnerIterator
{
	// NOTE see above
	enum
	{
		XprIsRowMajor = unary_evaluator::IsRowMajor
	};
	const unary_evaluator& m_eval;
	Index m_outerPos;
	const Index m_innerIndex;
	Index m_end;
	EvalIterator m_it;

  public:
	EIGEN_STRONG_INLINE OuterVectorInnerIterator(const unary_evaluator& aEval, Index outer)
		: m_eval(aEval)
		, m_outerPos((XprIsRowMajor ? aEval.m_block.startCol() : aEval.m_block.startRow()))
		, m_innerIndex(XprIsRowMajor ? aEval.m_block.startRow() : aEval.m_block.startCol())
		, m_end(XprIsRowMajor ? aEval.m_block.startCol() + aEval.m_block.blockCols()
							  : aEval.m_block.startRow() + aEval.m_block.blockRows())
		, m_it(m_eval.m_argImpl, m_outerPos)
	{
		EIGEN_UNUSED_VARIABLE(outer);
		eigen_assert(outer == 0);

		while (m_it && m_it.index() < m_innerIndex)
			++m_it;
		if ((!m_it) || (m_it.index() != m_innerIndex))
			++(*this);
	}

	inline StorageIndex index() const
	{
		return convert_index<StorageIndex>(m_outerPos -
										   (XprIsRowMajor ? m_eval.m_block.startCol() : m_eval.m_block.startRow()));
	}
	inline Index outer() const { return 0; }
	inline Index row() const { return XprIsRowMajor ? 0 : index(); }
	inline Index col() const { return XprIsRowMajor ? index() : 0; }

	inline Scalar value() const { return m_it.value(); }
	inline Scalar& valueRef() { return m_it.valueRef(); }

	inline OuterVectorInnerIterator& operator++()
	{
		// search next non-zero entry
		while (++m_outerPos < m_end) {
			// Restart iterator at the next inner-vector:
			m_it.~EvalIterator();
			::new (&m_it) EvalIterator(m_eval.m_argImpl, m_outerPos);
			// search for the key m_innerIndex in the current outer-vector
			while (m_it && m_it.index() < m_innerIndex)
				++m_it;
			if (m_it && m_it.index() == m_innerIndex)
				break;
		}
		return *this;
	}

	inline operator bool() const { return m_outerPos < m_end; }
};

template<typename _Scalar, int _Options, typename _StorageIndex, int BlockRows, int BlockCols>
struct unary_evaluator<Block<SparseMatrix<_Scalar, _Options, _StorageIndex>, BlockRows, BlockCols, true>, IteratorBased>
	: evaluator<SparseCompressedBase<Block<SparseMatrix<_Scalar, _Options, _StorageIndex>, BlockRows, BlockCols, true>>>
{
	typedef Block<SparseMatrix<_Scalar, _Options, _StorageIndex>, BlockRows, BlockCols, true> XprType;
	typedef evaluator<SparseCompressedBase<XprType>> Base;
	explicit unary_evaluator(const XprType& xpr)
		: Base(xpr)
	{
	}
};

template<typename _Scalar, int _Options, typename _StorageIndex, int BlockRows, int BlockCols>
struct unary_evaluator<Block<const SparseMatrix<_Scalar, _Options, _StorageIndex>, BlockRows, BlockCols, true>,
					   IteratorBased>
	: evaluator<
		  SparseCompressedBase<Block<const SparseMatrix<_Scalar, _Options, _StorageIndex>, BlockRows, BlockCols, true>>>
{
	typedef Block<const SparseMatrix<_Scalar, _Options, _StorageIndex>, BlockRows, BlockCols, true> XprType;
	typedef evaluator<SparseCompressedBase<XprType>> Base;
	explicit unary_evaluator(const XprType& xpr)
		: Base(xpr)
	{
	}
};

} // end namespace internal

} // end namespace Eigen

#endif // EIGEN_SPARSE_BLOCK_H
